Entwurf

Dieses Hilfethema behandelt den Entwurf einer Anwendung, insbesondere deren Modularisierung. Wenn Sie am programmiertechnischen Begriff des Moduls unter MS Access interessiert sind, dann erfahren Sie mehr unter Module in MS Access.

Anwendungsentwicklung

Unterschiedliche Komplexität der Anwendungsentwicklung

Endbenutzer können Software an ihre Bedürfnisse anpassen, ohne gleich ein Programm zu schreiben. Verbreitete Möglichkeiten der Anpassung (engl. customization) sind Vorlagen und Makros. Vorlagen (engl. templates) spielen vor allem in der Textverarbeitung und Tabellenkalkulation eine Rolle. Ein Textverarbeitungspaket erlaubt zum Beispiel die Definition von Textvorlagen (Textmustern) aus Konstanten und Variablen (auch Leerstellen oder Platzhalter genannt). Der Ersteller eines Serienbriefs verknüpft zum Beispiel die Platzhalter mit passenden Feldern einer Datenbank, zum Beispielen Adressfeldern, die nach jedem Brief ändern. Das Textverarbeitungsprogramm kann dann diese Daten abrufen und während des Druckens mit dem Template verknüpfen. In einem Serienbrief sind sind neben Adressfeldern die Anrede und die Grussformel verbreitete Platzhalter. Auch Entwickler von Tabellenblättern können Vorlagen erstellen. Dazu ersetzen sie jene Konstanten, die fallabhängig sind, durch Platzhalter.

Verlangt das Ausfüllen einer Vorlage viele manuelle Arbeitsschritte, so kann man eine zusammengehörende Folge von Tasten- und Mausaktionen als Makro aufzeichnen und später abspielen. Oft ist ein Makro der erste Schritt zur Entwicklung eines eigenen Programms. MS Excel erlaubt die Entwicklung von Programmen in der komfortablen Programmiersprache Visual Basic für Applikationen (VBA). Die folgenden Abschnitte vertiefen den Begriff des Makros und führen an einem Fallbeispiel in die Anwendungsentwicklung durch Modularisierung ein.

Deklarative und prozedurale Anwendungsentwicklung

Anwendungen deklarativ entwickeln heisst das Was einer Anwendung spezifizieren und das Wie der Software überlassen. Zum Beispiel setzen wir Formeln aus vordefinierten Funktionen und Konstanten in Tabellenzellen ein. Dabei überlassen wir die Definition der Funktionen, die Auswertung der Formeln und die Verknüpfung der Tabellenzellen MS Excel.

Prozedural entwickeln heisst hingegen das Wie einer Problemlösung entwerfen und schrittweise selbst  implementieren. Die Entwicklung von Programmen verläuft prozedural. Die folgende Tabelle vergleicht die deklarative und prozedurale Anwendungsentwicklung anhand der Kriterien Entwicklungsgeschwindigkeit, -komplexität, -flexibilität und -funktionalität:

Ein Makro automatisiert eine kleine Routineaufgabe, indem es mehrere Tasten- oder Mausaktionen aufzeichnet und unter einem Namen zusammenfasst. In einfachen Editoren fehlt zum Beispiel oft eine Funktion, welche den Text einer Zeile unterstreicht. Der Benutzer kann in diesem Fall den Makrorekorder einschalten, den Titel manuell unterstreichen und dann die Aufzeichnung beenden. Das entstandene Makroprogramm könnte wie folgt aussehen:

Macro Unterstreiche_die_laufende_Zeile
  Springe an den Anfang der nächsten Zeile
  For Zeilenlänge Times schreibe ‘-’
End Macro

Makroprogramme lassen sich meist nachträglich anpassen. In unserem Beispiel kann der Benutzer etwa das Unterstreichungszeichen - nachträglich durch * ersetzen. Wer über Programmierkenntnisse verfügt, kann das Makro auch als Grundlage eines eigenen Programms verwenden. Das obige Makro enthält nämlich wichtige Elemente von Programmen:

• Es fasst mehrere zusammengehörende Aktionen in einem benannten Programmbaustein (einem Modul) zusammen. Der Modulname lautet im obigen Beispiel Unterstreiche_die_laufende_Zeile.
• Es zeichnet eine Reihe von Aktionen auf, deren Reihenfolge (Sequenz) wichtig ist.
• Es wiederholt einige Aktionen x-mal. Das Beispiel wiederholt Zeilenlänge-mal die Aktion Schreibe ‘-’.
• Schlüsselwörter beschreiben den Ablauf von Programmen. Macro und End setzen zum Beispiel die Makrogrenzen, und For und Times beschreiben eine Schleife, die aus Zeilenlänge Wiederholungen besteht.

Bevor wir diese Programmmerkmale vertiefen, gehen wir kurz auf die praktische Bedeutung der Programmierung ein. Die drei folgenden Zeitungsmeldungen veranschaulichen die Bedeutung der Softwareentwicklung für Wirtschaft und Gesellschaft. Gleichzeitig glossieren sie die Schwierigkeit (oder gar Unmöglichkeit) einer geplanten und fehlerfreien Erstellung von Programmen.

• 47 Jahre vor Erreichung des Rentenalters haben jetzt alle volljährig gewordenen Bürger Neukölns die Broschüre “Leben in unserer Mitte - Vorbereitung aufs Rentenalter” vom Bezirksamt zugesandt bekommen. Normalerweise bekommen die Broschüre Personen, die vor dem Eintritt in das Rentenalter stehen, während den volljährig gewordenen ein Gruss des Bürgermeisters zugeht. Wie der Bezirk mitteilte, hat der Computer, in dem alle Namen gespeichert sind, wegen eines Defekts die beiden Namenslisten zusammengefasst.

• Ein Programm verrechnete sich bei der Schätzung des Steueraufkommens einer Stadt in den USA. Dies führte zu einer zu niedrigen Ansetzung der Steuerrate und so zu einem hohen Defizit in der Staatskasse.

• Die Versenkung des britischen Zerstörers “Sheffield” im Falklandkrieg soll durch ein fehlerhaftes Programm zur Steuerung von Abwehrraketen verursacht worden sein.

Man erzählt sich, dass alles mit einem Softwarefehler begann ...

Fussangeln für Softwareentwickler gibt es viele. Verbreitete Ursachen für Softwarefehler sind:

• Je grösser ein Programm wird, desto wahrscheinlicher sind komplexe Wechselwirkungen und desto folgenschwerer werden Fehler. Grosse Programme sind leider nicht immer vermeidbar. Die Software zur Steuerung des Jungfernflugs des amerikanischen Space Shuttle umfasste zum Beispiel eine halbe Million Codezeilen.

• Grosse Programme und kleine Zeitbudgets führen zu grossen Projektgruppen, die sich nur schwer koordinieren lassen.

• Zeitdruck wirkt sich oft in unsorgfältigen Tests aus. Ein sorgfältiger Test nimmt oft mehr Zeit in Anspruch als das eigentliche Programmieren.

Modularisierung am Beispiel einer Bibliotheksanwendung

Programmieren lernt man nur an kleinen überschaubaren Problemen. Bevor wir uns aber an Kleinprogramme setzen, veranschaulichen wir an einer Bibliotheksanwendung, wie ein Problem nach dem Grundsatz "Divide et impera" in Teilprobleme oder Module zerlegt wird, damit es programmiertechnisch einfacher gelöst werden kann.

Ein Modul ist ein entwurfs- oder programmiersprachlicher Baustein, der Aufgaben zusammenfasst, die eng verbunden sind. Ein einfaches Programmpaket zur Bibliotheksverwaltung lässt sich entwurfssprachlich zum Beispiel wie folgt modularisieren:

Bibliotheksverwaltung
    Ausleihverkehr buchen
    Stammdaten verwalten
        Dokumente verwalten
        Benutzer verwalten
    Statistiken erstellen
        Dokumentestatistiken
        ...
            Monatliche Ausleihstatistik
        ...
        Benutzerstatistiken

Die Beziehung zwischen den Modulen ist hierarchisch. Eingerückte Module gehören zum weiter oben ausgerückten Modul - zum Beispiel zu “Stammdaten verwalten” - und zum ganzen Programmsystem (hier “Bibliotheksverwaltung”). Eine Darstellung von Modulen in einer Einrückungsliste nennt man Modulhierarchie. Die obige Modulhierarchie ist unvollständig. Wir werden ausserdem nur eines der Teilprobleme vertiefen, nämlich das Modul Monatliche Ausleihstatistik.

Die Entwicklung eines Programmsystems ist zuerst eine schwierige aufbau- und ablauforganisatorische Aufgabe. Die programmtechnischen Probleme lassen sich oft leichter lösen als das Projektmanagement. Die bekannten Murphy-Gesetze gelten auch für die Softwareentwicklung:

• Wenn etwas schiefgehen kann, geht es bestimmt schief.
• Nichts ist so einfach, wie es aussieht.
• Alles wird teurer als zunächst geplant.
• Jede Arbeit erfordert mehr Zeit, als man hat.
• Es ist ein Naturgesetz, dass nichts jemals richtig klappt.
• Bevor man eine Sache anfangen kann, muss immer erst etwas getan werden.
• Alles lässt sich solange verbessern, bis es endlich zusammenbricht.
• Jede neue Erklärung schafft neue Verwirrung.
• Wer anderer Meinung ist, kann nicht logisch denken.
• Je wichtiger eine Entscheidung, desto grösser die Kommission.
• Mit zunehmender Dringlichkeit einer Entscheidung sinkt die Zahl der dafür Zuständigen.
• Sie können manche Leute immer und alle Leute manchmal zum Narren halten - und das genügt.

Probleme sind besser lösbar, wenn man sie in Teilprobleme zerlegt. Sie lassen sich insbesondere dann besser angehen, wenn man sie phasenweise löst. Entwicklungsprojekte kann man zum Beispiel wie folgt strukturieren:

1. Spezifikation

Eine Grobspezifikation dient dem Auftraggeber oft dazu, den vorläufigen Startschuss für das Projekt zu geben. Eine endgültige Entscheidung über den Fortgang des Projekts fällt aber meist nach einer Feinspezifikation und einer Machbarkeitsstudie.

Die Feinspezifikation kann sehr detailliert sein und zum Beispiel bereits die Benutzeroberfläche aus der Sicht der Anwender entwerfen. Grafische Benutzerschnittstellen erfordern einen sorgfältigen Entwurf der Bildschirmobjekte. Dazu gehören Formulare und Berichte sowie deren Steuerelemente. Wenn in der Implementationsphase (Phase 4) visuelle Entwicklungswerkzeuge wie MS Access und MS Excel zum Einsatz kommen, werden diese bereits als "Protyping Tools" eingesetzt. Die entstehenden Prototypen sind zwar nur "Kulissen", sie erleichtern aber die Beurteilung der Spezifikation, insbesondere des Dialogentwurfs, durch die Anwender.

Beispiel einer einfachen Spezifikation

2. Modularisierung

Diese Phase zerlegt das Programm in möglichst unabhängige Einheiten mit klarer Zielsetzung (Module). Die Modularisierung ist Grundlage der Arbeitsteilung in der Entwicklungsgruppe.

3. Entwurfssprachliche Algorithmisierung

Damit sich die abschliessende Codierung in einer Programmiersprache auf die technischen Details beschränken kann, wird die programmiersprachenunabhängige Logik in einer getrennten Phase beschrieben. Dazu verfeinert man die Modul-Einrückungsliste schrittweise in Verarbeitungsrezepte (Algorithmen). Meist setzt man dazu eine gut verständliche grafische Notation ein oder formuliert die Verarbeitungslogik in einer Enwurfssprache (Pseudocode), die sich an die Umgangssprache anlehnt.

4. Programmiersprachliche Codierung

Diese Phase übersetzt die Algorithmen in Programmcode, der von einem Computer ausgeführt werden kann.

5. Test

Die letzte Phase testet jedes Modul einzeln (Modultest) und abschliessend das Zusammenwirken aller Module (Systemtest).

Phasenschemata sind meist nur grobe Anhaltspunkte. Die fünf Phasen müssen sich nicht streng sequenziell folgen und ihre Ergebnisse sind in der Regel nur vorläufig. Zum Beispiel kann die Feinspezifikation in einer späteren Phase angepasst werden, oder ein kleiner Prototyp kann bereits in einer frühen Phase über den Fortgang des Projekts entscheiden. Wir illustrieren die ersten vier Phasen an einem stark vereinfachten Beispiel, dem Modul Monatliche Ausleihestatistik. Ausgangspunkt sei die folgende Grobspezifikation:

Programmieren Sie ein Modul, das eine Ausleihestatistik erstellt und nach dem folgenden Muster auf dem Bildschirm ausgibt:

AUSLEIHESTATISTIK	FÜR DEN MONAT F E B R U A R
Fachgebiet	Ausgeliehene Titel
BWL	***************************************
VWL	***********************************
RECHT	****************************
SOZ./PSYCH.	************
ÜBRIGE	***************

Diese Grobspezifikation ist vor allem deshalb ungenau, weil sie Fragen nach der Benutzereingabe und der Berechnung der Ausgabe offen lässt. Eine feinere Spezifikation des Moduls Monatliche Ausleihestatistik könnte wie folgt aussehen:

1. Modulzweck

Zweck des Moduls ist die Ausgabe eines Histogramms (Balkendiagramms) der Ausleihehäufigkeiten in den Fachgebieten Betriebswirtschaftslehre (BWL), Volkswirtschaftslehre (VWL), Recht, Soziologie/Psychologie und Übrige am Bildschirm.

2. Modulverarbeitung und -ausgabe

Das Histogramm visualisiert die relativen Ausleihehäufigkeiten der Fachgebiete BWL, VWL, Recht, Soziologie/Psychologie und Übrige. Die maximale Balkenlänge wird der grössten Häufigkeit zugeordnet. Die Häufigkeiten werden durch proportionale Balken aus “*” dargestellt.

3. Moduleingabe

Eingegeben werden auf der Tastatur die Ausleihehäufigkeiten der folgenden Fachgebiete: BWL, VWL, Oeffentliches Recht, Privates Recht, Soziologie, Psychologie und Übrige. Der Ausleihemonat soll als Zahl zwischen 1 bis 12 eingegeben werden.

Bei einer ersten Annäherung an die Spezifikation und den Entwurf eines Moduls hilft oft das EVA-Prinzip, das die Modulaufgaben in Eingabe, Verarbeitung und Ausgabe zerlegt:

Eingabe: Ausleihehäufigkeiten und -monat einlesen
Verarbeitung: Ausgabe des Histogramms vorbereiten
Ausgabe: Histogramm auf dem Bildschirm ausgeben

In einem zweiten Schritt verfeinern wir das EVA-Schema als eine Folge von Einrückungslisten:

Ausleihehäufigkeiten und -monat einlesen
    Programmtitel ausgeben
        Für jede Ausleihehäufigkeit:
            Prompt "Ausleihehäufigkeit"
            Ausleihehäufigkeit lesen
            Ausleihehäufigkeit prüfen
        Prompt "Ausleihemonat"
        Monatszahl lesen
        Monatszahl prüfen

Ausgabe des Histogramms vorbereiten
    Maximale Häufigkeit ermitteln

Histogramm auf dem Bildschirm ausgeben
    Ausgabetitel ausgeben
    Spaltenbezeichner ausgeben
    Für jede Ausgabehäufigkeit:
        Zeilenbezeichner ausgeben
        Balken ausgeben

Man formuliert diese Verfeinerung des EVA-Schemas nicht im Code der Programmiersprache, sondern entwurfssprachlich. Die Granularität (der Verfeinerungsgrad) des Pseudocode ist in unserem Beispiel gross. Im allgemeinen wird der Pseudocode wesentlich weniger Zeilen enthalten als der eigentliche Programmcode.

Von dieser zweiten Entwurfsstufe verfeinern wir wieder nur einen Teil, nämlich die Struktur der Daten und den Ablauf des Untermoduls Maximale Häufigkeit ermitteln. Die meisten Programmiersprachen kennen Datenstrukturen, die Listen speichern. Eine Struktur, die eine Liste gleichartiger Daten speichert, heisst Datenfeld. Das folgende Datenfeld nennen wir Ausgabehäufigkeit und speichert die Häufigkeiten der ausgeliehenen Bücher nach Fachgebieten:

Der Befehl Ausleihehäufigkeit(i) greift auf die i-te Zelle des Datenfelds mit dem Namen Ausleihehäufigkeit zu. Der folgende Visual Basic-Code geht durch alle Werte dieses Datenfelds und ermittelt die maximale Ausleihehäufigkeit. Wir benötigen sie zur Berechnung der maximalen Balkenlänge. Im Gegensatz zum obigen (grün unterlegten) Entwurfs"code" kann der folgende Visual Basic-Code von einem Rechner ausgeführt werden. Ausführbaren Code unterlegen wir deshalb nicht grün, sondern grau:

Maximum = Ausleihehäufigkeit(1)
For i = 2 To 5
  If Ausleihehäufigkeit(i) > Maximum
    Maximum = Ausleihehäufigkeit(i)
  End If
Next i

Die erste Zeile weist einer Speicherzelle mit dem Namen Maximum die Ausleihehäufigkeit von BWL zu. Die Zeilen 2 bis 6 lesen nacheinander alle übrigen Elemente des Datenfelds Ausleihehäufigkeit. Zeile 4 überschreibt jeweils die Speicherzelle Maximum mit dem laufenden Element, sobald dieses grösser als der Inhalt von Maximum ist (= vergleicht also nicht zwei Werte, sondern überschreibt den Wert in der Speicherzelle Maximum mit dem Wert von Ausleihehäufigkeit(i). Nach dem Lesen aller Elemente des Datenfelds steht in Maximum die grösste Ausleihehäufigkeit.

Dieses Hilfethema möchte Sie nur in die Grundlagen der Programmentwicklung einführen. Die eben angesprochenen Inhalte werden in den folgenden Themen vertieft: Datenfeld (Ausleihehäufigkeit), Entscheidungsanweisung (If ... Then) und Wiederholungsanweisungen (For ... Next).

Programmiersprachen

Anwendungen lassen sich mit einer Vielfalt von Werkzeugen entwickeln. MS Office (und einige andere Softwarepakete) bieten mit VBA (Visual Basic für Applikationspakete) eine komfortable Entwicklungsumgebung an. VBA deckt sich praktisch mit seiner Muttersprache Visual Basic (VB). Der Hauptunterschied besteht darin, dass man in Visual Basic auch Anwendungen entwickeln kann, die nicht auf das Vorhandensein von MS Office oder einem anderen Applikationspaket angewiesen sind (engl. standalone applications). VB(A) ist eine Programmierumgebung, die sich besonders leicht für die schnelle Programmentwicklung eignet. Wer besonders effiziente Anwendungen oder Systemsoftware implementieren möchte, greift aber besser zu Programmiersprachen wie C.

Programmiersprachen vermitteln zwischen dem menschlichen Entwickler und dem Rechner. Trotzdem sind sie weder für den Menschen noch für die Maschine ohne weiteres verständlich. Der Mensch muss sowohl die Form als auch die Bedeutung einer Programmiersprache lernen, bevor er ein Programm erstellen kann. Die Maschine versteht ein Programm erst, nachdem ein Übersetzer (engl. compiler oder interpreter) das Programm in den Maschinencode eines bestimmten Rechners transformiert hat. Falls die Form eines Programms nicht der Grammatik (Syntax) der Programmiersprache entspricht, wird der Übersetzer dem Programmier mehr oder weniger verständlich mitteilen, wo und worin der Fehler liegt. Der Code des folgenden Bildschirmausschnitts enthält ein fehlerhaftes VBA-Programm und das nachfolgende Bild zeigt, wie der Übersetzer reagiert, falls der Benutzer das Programm übersetzen möchte.

Der Programmierer beginnt die Bedingung Age > 10 mit einer linken Klammer und vergisst die rechte Klammer zu setzen. Der Übersetzer markiert die fehlerhafte Stelle deshalb rot und zeigt eine entsprechende Fehlermeldung an.

Beispiel einer Spezifikation